# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
# def index(range_index):
#     new_list = []
#     for i in range(len(range_index)):
#         if i%2!=0:
#             new_list.append(range_index[i])
#     return new_list
#
# list1 = [3,4,9,11,12,15,17,19]
# print(index(list1))


# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
# def istype(value):
#     if isinstance(value,str):
#         if len(value) > 5:
#             return f"传入的是字符串对象{value}，长度大于5"
#     elif isinstance(value,list):
#         if len(value) > 5:
#             return f"传入的是列表对象{value}，长度大于5"
#     elif isinstance(value,tuple):
#         if len(value) > 5:
#             return f"传入的是元组对象{value}，长度大于5"
# print(istype("asdasdasd"))
# print(istype([123,456,789,531,564,23,156]))
# print(istype((41,23156,1,231,561,896,1,23,1,56)))
# print(istype("asd"))

# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
# def count(content):
#     int_num = 0
#     str_num = 0
#     space_num = 0
#     other_num = 0
#     for i in content:
#         if i in "0123456789":
#             int_num+=1
#         elif (i >= 'a' and i <='z') or (i >="A" and i <='Z'):
#             str_num+=1
#         elif i == " ":
#             space_num+=1
#         else:
#             other_num+=1
#     return f"整数有{int_num}个，字母有{str_num}个,空格有{space_num}个,其他有{other_num}个"
# print(count("asd123  !@#$%"))

# 4、写函数,接收两个数字参数,返回较大的那个数字
# def find_max_num(a,b):
#     if a > b:
#         return a
#     else:
#         return b
#
# print(find_max_num(5,10))
# print(find_max_num(100,10))


# 5、佩奇去超市购买54元巧克力和53元果冻，货币面值有20、10、2、1元，
# 按付款货币数量最少原则，佩奇需要付给超市多少数量的货币，编写函数实现该算法。
# def shopping(money):
#     num = money /20
#     if isinstance(num,float):
#         return f"最少需要{round(num+1)}张才可以购买"
#     else:
#         return f"最少需要{round(num)}张才可以购买"
# print(shopping(107))


# 6、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
# 元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.
# def cacluate(*agrs):
#     num = sum(agrs)/len(agrs) # 平均值
#     new_list = [] # 收集所有大于平均值的列表
#     for i in agrs: # 循环所有的参数
#         if i > num: # 如果某个值大于了平均值
#             new_list.append(i)  # 就把平均值加到列表里
#     return (num,tuple(new_list)) # 最后返回了第一个是平均值，第二个值是大于平均值的元组
# print(cacluate(1,56,4561,89,153,1,561,56,132,1,561,56,1,321,32))


# 7、编写一个函数, 接收字符串参数, 返回一个元组,
# 元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
# def zifuchuan(aa): # aa是形参
#     sum_1=0 # 定义了一个收集器，专门收写大写字母的个数
#     sum_2=0 # 定义了一个收集器，专门收写小写字母的个数
#     for i in aa: # 遍历传入的aa形参
#         if i>="A" and i<="Z": # 如果说某个值大于了A，并且小于等于Z
#             sum_1=sum_1+1 # 大写收集器+1
#         elif i>="a" and i<="z":
#             sum_2=sum_2+1
#     return (sum_1,sum_2)
#
# aaa="asdkhajdASJD"
# print(zifuchuan(aaa))


# 8、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)
# 和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
# from random import randint
# new_list = []
# def get_num(list,k):
#     if k <0 or k >len(list)-1: # 判断k角标的长度不能小于0，或者说k这个索引的长度不能越界
#         return "index error"
#     if len(list) > 30: # 判断列表的长度不能大于30
#         return "error length"
#     k_one = list[:k] # 将列表下标k之前对应(不包含k)的元素
#     k_one.reverse() # 逆序
#     k_two = list[k:] # 将下标k及之后的元素
#     k_two.reverse() # 逆序
#     return k_one+k_two # 返回结果
# list1 = []
# for i in range(30):
#     num = randint(1,100)
#     list1.append(num)
# print(get_num(list1,5))

# 9、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
# def sum_x(x,n):
#     sum = 0
#     for i in range(1,n+1):
#         k = 0
#         for j in range(0,i):
#             k += x * pow(10,j)
#         sum +=k
#     print(sum)
# number_x = int(input("请输入X的值："))
# number_xu = int(input("请输入X的次数："))
# sum_x(number_x,number_xu)
# def sum_num(x,n):
#     sum = x # sum给一个初始值x
#     a = x # x赋值给了a ，a为不变的变量
#     while (n-1): # 如果循环n-1,为0则不循环
#         x = x*10+a # 5*10+5
#         sum+=x# sum求和收集器
#         n-=1 # 循环每次-1
#     return sum # 返回sum
#
# print(sum_num(5,3))


# 10、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
# 用户通过input输入这4个内容(支持持续输入,Q或q退出),并传递给函数函数接收到这些内容,将其追加到student_msg文件中

# 重点:复习文件操作
# def get_value_list():
#     while True:
#         name = input("请输入姓名")
#         if name == 'Q' or name =='q':
#             break
#         age = input("请输入年龄")
#         if age == 'Q' or age =='q':
#             break
#         address = input("请输入地址")
#         if address == 'Q' or address =='q':
#             break
#         sex = input("请输入性别")
#         if sex == 'Q' or sex =='q':
#             break
#         elif sex == "":
#             sex = "男"
#         result = f"姓名-{name},年龄-{age},地址-{address},性别-{sex}"
#         with open("./student_msg.txt",'a',encoding='utf-8') as f:
#             f.write(result + "\n")
#
#
# get_value_list()




# 11、写函数,接收n个数字,返回这些数字的和(动态传参)
# def sum_n(*n):
#     sum = 0
#     for i in n:
#         sum+=i
#     return f"所有的和是{sum}"
#
#
# print(sum_n(5, 6, 7, 8))




# 12、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
# def get_all(*args,**kwargs):
#     for i in args:
#         print(i,end=" ")
#     print()
#     for j in kwargs.values():
#         print(j,end=" ")
# get_all(156,123,156,姓名 = "刘闯")



# 13、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
# def add_(list):
#     new_list = [] # 创建一个空的列表，用于收集处理好的列表内容
#     for i in range(len(list)): # 根据列表的长度循环
#         if list[-1] == list[i]: # 如果列表的最后一个角标 等于 列表中的某个角标值的话
#             new_list.append(list[i]) # 那么把列表的这个值添加到新的列表里
#         else: # 反之
#             list[i] += '_' # 列表中的值，加上下划线
#             new_list.append(list[i]) #  添加到新的列表里
#     return new_list # 返回列表
# print(add_(['asd','qwe','poi']))



# 14、写函数,传入一个数字,返回这个数的阶乘
# 重点:累乘
#
# 示例：1x2x3....
# def factorial(n):
#     a = 1 # 定义a 为1
#     for i in range(1,n+1): # 循环n+1，因为最后一个n不会走到，比如你传入的n是3，那么循环最后也就到了2
#         a*=i # 累乘
#     return a # 返回a
# print(factorial(3))


# 15、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple

# def poker():
#     poker_list = [] # 定义一个空列表，收集所有的扑克牌
#     for i in ['梅花','方片','红桃','黑桃']: # 循环'梅花','方片','红桃','黑桃'
#         for j in [3,4,5,6,7,8,9,10,'J','Q','K','A',2]:
#             poker_list.append((i,j))
#     return poker_list
# print(poker())



# 16、用代码写一个99乘法表


# 17、编写函数，求1+2+3+…N的和
# def sum_num(n): # 传入n
#     sum = 0
#     for i in range(n+1): # 因为最后一个走不到，所以+1
#         sum+=i
#     return sum # 返回sum所有的和
# print(sum_num(5)) # 1+2+3+4+5


# 18、编写一个函数，求多个数中的最大值
# def max_num(*a):
#     list = []
#     for i in a:
#         list.append(i)
#     list.sort(reverse=True)
#     return list[0]
# print(max_num(781,5616,51,5361,56,123,1,561,32,156,4,896))


# 19、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
# def Extract_specified_string(string1):
#     str1 = "" # 定义了一个空字符串
#     for i in string1: # 遍历字符串
#         if (i >='a' and i<='z') or (i >='A' and i<='Z'): # 如果i小于a
#             str1+=i
#     return str1 # 返回
# print(Extract_specified_string('asd132asd123qwAA1564231AADAS1'))



# 20、编写一个函数，使用冒泡排序将一个列表由大到小排序
# def pai(list1):
#     for i in range(len(list1)):
#         for j in range(len(list1)-i-1):
#             if list1[j] > list1[j+1]:
#                 list1[j],list1[j+1] = list1[j+1],list1[j]
#     return list1
# print(pai([12156,4815,318561,563,156,1563,1,56,1,23,156,1,8,534,864,89]))



# 21、写一个函数，求多个数的平均值

# 22、写一个自己的len函数，统计指定序列中元素的个数
# def count(value):
#     sum =0
#     if isinstance(value,(tuple,int,str,set)):
#         for i in value:
#             sum+=1
#         return f"个数为{sum}"
#     else:
#         for i in value.values():
#             sum+=1
#         return f"个数为{sum}"
#
#
# print(count("asdasdsadsad"))



# 23、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
# def new_list(value): # 传入的列表或元组
#     new_list1 = []
#     for i in range(len(value)):
#         if i%2!=0: # 循环判断奇数位对应的元素
#             new_list1.append(value[i]) # 找到，添加到列表里
#     return new_list1 # 并返回一个新的列表
# print(new_list([12,33,66,44,77])) # [33,44]



# 24、水仙花数：个位、十位、百位的立方加在一起等于数的本身，
# def Narcissistic_number_number(number):
#     if int(str(number[0]))**3 + int(str(number[1]))**3 + int(str(number[2]))**3:
#         return f"你输入的这个{number}数，是水仙花"
#     else:
#         return f"你输入的这个{number}数，不是水仙花"
#
# print(Narcissistic_number_number("153")) # 1*1*1 + 5*5*5 + 3*3*3 = 153


# 25、定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# # 数组中的每个元素值不允许超过 100，但是可以等于100，
# # 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
#
# # 删除所有重复元素，使得每个元素只出现一次
# # 按照数字的大小，由高到低排序返回
# def Return_List(list1):
#     if len(list1) > 100: # 判断列表的长度，如果大于了100
#         list1 = list1[:100] # 切片 ，就保留100位
#     for i in range(len(list1)): # 根据list1长度循环
#         if list1[i] >100: # 如果列表中的某个值大于100
#             return "数组中有超过100的值" # 直接返回，数组中有超过100的值
#         else:
#             pass # 反之，pass，就占个位，啥也不干
#
#     new_list = list(set(list1)) # 去重。转成集合是最快的方式，再转成列表
#     new_list.sort(reverse=True) # 列表降序
#     return new_list # 返回新列表
#
# list2 = [i for i in range(1,110)]
# list2.append(55)
# print(Return_List(list2))


#
# 26、定义函数 getLength，打印用户传入的容器类型和数据长度
# def getLength(value):
#     if isinstance(value,list):
#         return f"是列表，长度是{len(value)}"
#     elif isinstance(value,tuple):
#         return f"是元组，长度是{len(value)}"
#     elif isinstance(value,set):
#         return f"是集合，长度是{len(value)}"
#     elif isinstance(value,dict):
#         return f"是字典，长度是{len(value.values())}"
#     elif isinstance(value,str):
#         return f"是字符串，长度是{len(value)}"
#
#
# print(getLength([123, 456, 123, 156, 123, 1, 56]))
# print(getLength((123, 456, 123, 156, 123, 1, 56)))
# print(getLength({123, 456, 123, 156, 123, 1, 56}))
# print(getLength({"asd": "asd"}))
# print(getLength("asd"))


# 27、定义函数 generateNum( )
# # 返回从0~9的十个数字中随机取出4个不重复的数字组成一个字符串
# def generateNum():
#     str1 = '0123456789' # todo：定义0~9的字符串
#     str2 = "" # todo：定义一个空的字符串用来收集
#     import random
#     while True:
#         str_random = random.choice(str1) # todo：每次随机生成一个数，并返回
#         if str_random not in str2: # todo：如果 随机生成一个数 不在str2里面的话
#             str2+=str_random # todo：用空的字符串收集起来
#         if len(str2) == 4: # todo：如果收集起来的字符串长度等于4了，说明我收集够了
#             break # todo：循环可以停止掉
#     return str2 # todo：返回字符串随机四位数
#
# print(generateNum())



# 28、定义函数 moreThan(num)，判断输入的数字是否大于1500
# def moreThan(num):
#     try:
#         if num > 1500:
#             return "大于1500"
#         elif num <= 1500:
#             return "小于等于1500"
#     except:
#         return "error"
# print(moreThan(1599))
# print(moreThan(1499))
# print(moreThan("asdasd"))



# 29、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
#
# 示例：func_a(5,10)
# 5x5+6x6+7x7+8x8+9x9+10x10...
# def func_a(a,b):
#     sum = 0
#     for i in range(a,b+1): # 循环开始到结束的值，结束的值+1
#         sum += i**2 # sum收集器，收集每次i平方值
#     return sum # 最终返回收集器，就是结果
# print(func_a(5,10)) # 25 + 36 + 49 + 64 + 81 + 100




# 30、写函数，检查传入字典的每一个value长度，如果大于2，
# # 那么仅保留前两个长度的内容， 并将新内容返回给调用者
# dict1 = {"姓名":"刘闯大坏蛋","地址":"河北省秦皇岛市"}
# def Determine_length(dict1):
#     for key,value in dict1.items(): # 循环每组的key和value
#         if len(value) > 2: # 如果value的长度大于了2
#             dict1[key] = str(value)[:2] # 那么切片，就保留两位
#     return dict1 # 返回新的字典
# print(Determine_length(dict1))



# 31、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
# def Determine_value_isNull(value):
#     if isinstance(value,(str,list,tuple)):
#         if value:
#             return f"不为空"
#         else:
#             return "为空"
#     else:
#         return "不是字符串，也不是列表，也不是元组"
#
#
# print(Determine_value_isNull("asd"))
# print(Determine_value_isNull(""))
# print(Determine_value_isNull({}))
# print(Determine_value_isNull(()))



# 32、编写自定义函数，完成一个简单的减法运算函数
# def calculator(a,b):
#     try:
#         if ((type(a) and type(b)) == int) or ((type(a) and type(b)) == float):
#             return a-b
#     except:
#         return "不是数，运算不了"
# print(calculator(5,6))



# 33、编写自定义函数，可以输出自己的名字即可。
# def get_name():
#     name = input("姓名")
#     print(name)
# get_name()



# 34、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
#
# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
#
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
#
# 1 代表剪刀 2 代表石头 3 代表布
# def wegame():
#     user = 100
#     computer = 100
#     gesture = ['剪刀','石头','布']#{'1':"剪刀",'2':"石头",'3':"布"}
#     import random
#     while True:
#         fist = input("请出拳") # 用户出拳
#         fist_computer = random.choice(gesture) # 电脑出拳
#         if fist == gesture[0] and fist_computer == gesture[0]:
#             print("这局扯平，不扣分")
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[0] and fist_computer == gesture[1]:
#             print("这局你输了，电脑出的是石头！")
#             user-=10
#             computer+=10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[0] and fist_computer == gesture[2]:
#             print("这局你赢了，电脑出的是布！")
#             user += 10
#             computer -= 10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[1] and fist_computer == gesture[0]:
#             print("这局你赢了，电脑出的是剪刀！")
#             user += 10
#             computer -= 10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[1] and fist_computer == gesture[1]:
#             print("这局扯平，不扣分")
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[1] and fist_computer == gesture[2]:
#             print("这局你输了，电脑出的是布！")
#             user -= 10
#             computer += 10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[2] and fist_computer == gesture[0]:
#             print("这局你输了，电脑出的是剪刀！")
#             user -= 10
#             computer += 10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[2] and fist_computer == gesture[1]:
#             print("这局你赢了，电脑出的是石头！")
#             user += 10
#             computer -= 10
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         elif fist == gesture[2] and fist_computer == gesture[2]:
#             print("这局扯平，不扣分")
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#         if user == 200 or user == 0:
#             print("游戏结束")
#             print(f"你还有分数{user}，电脑还有分数{computer}")
#             break
# wegame()
# 35、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
# def get_string(str1):
#     return str1[::-1]
#
# print(get_string("asdasd"))

# 36、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
# def number_list(list):
#     new = []
#     for i in list:
#         if i%2==0:
#             new.append(i)
#     return new

# 37、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
# str_list = ['asd','qwewqe','dasdqwd']
# def Return_Max_str(str_list):
#     max_length = len(str_list[0]) # 第一个用作比对的长度
#     str2 = "" # 空字符串
#     for i in range(len(str_list)): # 根据长度循环
#         if len(str_list[i]) > max_length: # 如果某个长度大于了比对的
#             max_length = len(str_list[i]) # 那么最大长度发生改变
#             str2=str_list[i] #  每次找到最大的值，去赋值替换
#     return str2
#
#
# print(Return_Max_str(str_list))


# 38、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
# def get_numberList(numberList):
#     sum = 0
#     for i in numberList:
#         sum += i**2
#     return sum
# print(get_numberList([1,2,3,4,5,6])) # 1*1 + 2*2 + 3*3 + 4*4 + 5*5 +6*6





# 39、编写一个函数，接受一个整数作为参数，并返回其阶乘


# 40、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
# def String_capitalizations(str1):
#     str2 = str1.capitalize()
#     return str2
# print(String_capitalizations("asdasdas"))
# "asd".capitalize()

# 41、编写一个函数，接受一个字符串列表作为参数，并返回一个字符串，其中包含所有字符串首字母的大写形式




# 42、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
#
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
# def ss(a,b):
#     new_list = []
#     for i in range(len(a)):
#         for j in range(len(a)):
#             if a[i] == b[j]:
#                 new_list.append(a[i])
#     return new_list
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# print(ss(list1, list2))


# 43、 定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市， 使用默认参数降低调用函数的复杂度
def enroll(学生姓名,性别,年龄,城市 = "沈阳"):
    print(学生姓名,性别,年龄,城市)
enroll("刘闯","女",99)


